#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <malloc.h>
#include <assert.h>
#include "ActionsEnnemis.h"

void ennemiTombe (terrain* T, personnage* Ennemi, float vitesse)
{
	Gravite (T, Ennemi, vitesse);
}

void volAGauche (terrain* T, celluleEnnemi* Ennemi, float vitesse)
{
		blocMouvement (Ennemi->Ennemi->hitBox, 0, -1*vitesse);
}

void volADroite (terrain* T, celluleEnnemi* Ennemi, float vitesse)
{
		blocMouvement (Ennemi->Ennemi->hitBox, 0, vitesse);
}

void ennemiBougeAGauche (terrain* T, celluleEnnemi* Ennemi, float vitesse)
{
    Gravite(T, Ennemi->Ennemi, 3*vitesse);
    volAGauche (T, Ennemi, vitesse);
}

void ennemiBougeADroite (terrain* T, celluleEnnemi* Ennemi, float vitesse)
{
    Gravite (T, Ennemi->Ennemi, 3*vitesse);
    volADroite (T, Ennemi, vitesse);
}

void ennemiSuitHeros (terrain* T, personnage* Heros, celluleEnnemi* Ennemi, float vitesse)
{
    Gravite(T, Ennemi->Ennemi, 3*vitesse);
    if (Heros->hitBox->pos.x > Ennemi->Ennemi->hitBox->pos.x && !persoRencontreMurADroite (T, Ennemi->Ennemi))
    {
        ennemiBougeADroite (T, Ennemi, vitesse);
    }
    else if (Heros->hitBox->pos.x < Ennemi->Ennemi->hitBox->pos.x && !persoRencontreMurAGauche (T, Ennemi->Ennemi))
    {
        ennemiBougeAGauche (T, Ennemi, vitesse);
    }
}

int projectileEnnemiDansChargeur (personnage* P, projectile* Munition)
{
    assert (P != NULL);
	assert (Munition != NULL);
	if (contactBloc(P->hitBox, Munition->hitBox))
	{
		return 1;
	}
	return 0;
}

void setDirectionTirUnique (personnage* E, int direction)
{
    int i;
    for (i = 0 ; i < E->nbMunitions ; i++)
    {
        setDirectionTir(E->munition[i], direction);
    }
}

void tirEnnemiSensUnique (terrain* T, personnage* Heros, personnage* Ennemi)
{
    int i, dim = Ennemi->hitBox->dim/2;
    float newX = Ennemi->hitBox->pos.x + dim , newY = Ennemi->hitBox->pos.y + dim;
    projectile* P;
    for (i = 0 ; i < Ennemi->nbMunitions ; i++)
    {
        P = Ennemi->munition[i];
        if (!projectileRencontreMur(T, P))
        {
            if (!contactBloc(Heros->hitBox, P->hitBox))
            {
                Tir (P);
            }
            else
            {
                personnageToucheProjectile (Heros, P);
                setPosition(P->hitBox, newX, newY);
            }
        }
        else
        {
            setPosition(P->hitBox, newX, newY);
        }
    }
}

void ciblageHeros (personnage* Heros, personnage* Ennemi)
{
    int i;
    projectile* P;
    for (i = 0 ; i < Ennemi->nbMunitions ; i++)
    {
        if (projectileEnnemiDansChargeur(Ennemi, Ennemi->munition[i]))
        {
            P = Ennemi->munition[i];
            if (Ennemi->hitBox->pos.y > Heros->hitBox->pos.y)
            {
                if (Ennemi->hitBox->pos.x > Heros->hitBox->pos.x)
                {
                    if (2*(Ennemi->hitBox->pos.x - Heros->hitBox->pos.x) < Ennemi->hitBox->pos.y - Heros->hitBox->pos.y)
                    {
                        setDirectionTir (P, 4);
                    }
                    else if (Ennemi->hitBox->pos.x - Heros->hitBox->pos.x > 2*(Ennemi->hitBox->pos.y - Heros->hitBox->pos.y))
                    {
                        setDirectionTir (P, 2);
                    }
                    else
                    {
                        setDirectionTir (P, 8);
                    }
                }
                else
                {
                    if (2*(Heros->hitBox->pos.x - Ennemi->hitBox->pos.x) < Ennemi->hitBox->pos.y - Heros->hitBox->pos.y)
                    {
                        setDirectionTir (P, 4);
                    }
                    else if (Heros->hitBox->pos.x - Ennemi->hitBox->pos.x > 2*(Ennemi->hitBox->pos.y - Heros->hitBox->pos.y))
                    {
                        setDirectionTir (P, 1);
                    }
                    else
                    {
                        setDirectionTir (P, 7);
                    }
                }
            }
            else
            {
                if (Ennemi->hitBox->pos.x > Heros->hitBox->pos.x)
                {
                    if (2*(Ennemi->hitBox->pos.x - Heros->hitBox->pos.x) < Heros->hitBox->pos.y - Ennemi->hitBox->pos.y)
                    {
                        setDirectionTir (P, 3);
                    }
                    else if (Ennemi->hitBox->pos.x - Heros->hitBox->pos.x > 2*(Heros->hitBox->pos.y - Ennemi->hitBox->pos.y))
                    {
                        setDirectionTir (P, 2);
                    }
                    else
                    {
                        setDirectionTir (P, 6);
                    }
                }
                else
                {
                    if (2*(Heros->hitBox->pos.x - Ennemi->hitBox->pos.x) < Heros->hitBox->pos.y - Ennemi->hitBox->pos.y)
                    {
                        setDirectionTir (P, 3);
                    }
                    else if (Heros->hitBox->pos.x - Ennemi->hitBox->pos.x > 2*(Heros->hitBox->pos.y - Ennemi->hitBox->pos.y))
                    {
                        setDirectionTir (P, 1);
                    }
                    else
                    {
                        setDirectionTir (P, 5);
                    }
                }
            }
        }
    }
}

void ActionsEnnemis (terrain* T, listeEnnemis* L, celluleEnnemi* E, personnage* Heros)
{
	int dim = T->tab[0][0]->dim;
	switch (E->action)
	{
		case (1) :
			if (Heros->hitBox->pos.x - E->Ennemi->hitBox->pos.x < 3*dim)
			{
				ennemiTombe (T, E->Ennemi, 0.5*dim); /* L'ennemi tombe */
			}
			break;
		case (2) :
				volADroite (T, E, 0.2*dim);
                if (persoRencontreMurADroite(T, Heros))
                {
                    E->action = 3;
                }
			/* L'ennemi vole vers la gauche et change de sens s'il croise un mur */
			break;
		case (3) :
                volADroite (T, E, 0.2*dim);
                if (persoRencontreMurAGauche(T, Heros))
                {
                    E->action = 2;
                }
			/* L'ennemi vole vers la droite et change de sens s'il croise un mur */
			break;
		case (4) :
                ennemiBougeAGauche (T, E, 0.2*dim);
                if (persoRencontreMurAGauche (T, E->Ennemi))
                {
                    E->action = 5;
                }
			/* L'ennemi avance au sol de droite a gauche */
			break;
		case (5) :
                ennemiBougeADroite (T, E, 0.2*dim);
                if (persoRencontreMurADroite (T, E->Ennemi))
                {
                    E->action = 4;
                }
			/* L'ennemi avance au sol de gauche a droite */
			break;
		case (6) :
                ennemiSuitHeros (T, Heros, E, 0.2*dim);
			/* L'ennemi avance dans la direction du personnage principal */
			break;
		case (7) :
                tirEnnemiSensUnique (T, Heros, E->Ennemi);
			/* L'ennemi tire dans une direction donnee */
			break;
		case (8) :
                ciblageHeros (Heros, E->Ennemi);
                tirEnnemiSensUnique (T, Heros, E->Ennemi);
			/* L'ennemi tire en essayant de viser le personnage */
			break;
		case (9) :
				ennemiSuitHeros (T, Heros, E, 0.2*dim);
				ciblageHeros (Heros, E->Ennemi);
                tirEnnemiSensUnique (T, Heros, E->Ennemi);
			/* L'ennemi suit le heros et essaie de lui tirer dessus */
			break;
		case (10) :
			/* Le boss suit un deplacement precis */
			break;
		case (11) :
			/* Le boss tire plusieurs projectiles a la fois */
			break;
		case (12) :
			/* Le boss avance en direction du personnage */
			break;
	}
}

void actionsTestRegression ()
{

}

